בית הספר למדעי המחשב אוניברסיטת תל אביב תוכנה 1 תרגול מספר 9: הורשה מחלקות אבסטרקטיות חריגים

Transcription

1 בית הספר למדעי המחשב אוניברסיטת תל אביב תוכנה 1 תרגול מספר 9: הורשה מחלקות אבסטרקטיות חריגים

2 2 ירושה ממחלקות קיימות ראינו בהרצאה שתי דרכים לשימוש חוזר בקוד של מחלקה קיימת: הכלה + האצלה הכלה )aggregation( במחלקה א' יש שדה מטיפוס מחלקה ב' האצלה )delegation( קוראים מתוך מתודות במחלקה א' למתודות של מחלקה ב' ירושה המחלקה היורשת יכולה להוסיף פונקציונאליות שלא היתה קיימת במחלקת הבסיס, או לשנות פונקציונאליות שקיבלה בירושה

3 3 דריסת שירותים המחלקה היורשת בדרך כלל מייצגת תת-משפחה של מחלקת הבסיס המחלקה היורשת יכולה לדרוס שירותים שהתקבלו בירושה כדי להשתמש בשירות המקורי )למשל מהשירות הדורס( ניתן לפנות לשירות המקורי בתחביר: super.methodname) (

4 4 שימוש בשירות המקורי מתוך השירות הדורס class B { protected int a; protected int b; public String tostring(){ return "a: " + this.a + " b: " + this.b; { class C extends B{ private int c; public String tostring(){ return super.tostring() + " c: " + this.c; { {

5 5 ניראות והורשה שדות ושירותים פרטיים למחלקה היורשת )private( של מחלקת הבסיס אינם נגישים כדי לאפשר גישה למחלקות יורשות יש להגדיר להם נראות protected שימוש בירושה יעשה בזהירות מרבית, בפרט הרשאות גישה למימוש נשתמש ב protected רק כאשר אנחנו מתכננים היררכיות ירושה שלמות ושולטים במחלקה היורשת

6 6 צד הלקוח בהרצאה ראינו את המנשק עבורו,IPoint והצגנו 3 מימושים שונים ראינו כי לקוחות התלויים במנשק IPoint בלבד, ואינם מכירים את המחלקות המממשות, יהיו אדישים לשינויים עתידים בקוד הספק שימוש במנשקים חוסך שכפול בקוד לקוח, בכך שאותו קטע קוד עובד בצורה נכונה עם מגוון ספקים )פולימורפיזם( <<interface>> IPoint << class >> Rectangle <<class>> CartesianPoint <<class>> PolarPoint <<class>> SmartPoint

7 7 public interface IPoint { /** returns the x coordinate of the current point*/ public double getx(); /** returns the y coordinate of the current point*/ public double gety(); /** returns the distance between the current point and (0,0) */ public double rho(); /** returns the angle between the current point and the abscissa */ public double theta(); /** move the current point by dx and dy */ public void translate(double dx, double dy); /** rotate the current point by angle degrees with respect to (0,0) */ public void rotate(double angle); הממשק IPoint

8 8 צד הספק לעומת זאת, מנגנון ההורשה חוסך שכפול קוד בצד הספק ע"י הורשה מקבלת מחלקה את קטע הקוד בירושה במקום לחזור עליו. שני הספקים חולקים אותו הקוד פתרון אלטרנטיבי הוא להשתמש במתודות דיפולטיות במנשק ננסה לזהות את שכפול הקוד בין 3 מימושי המנשק IPoint ולרכז קטעים משותפים אלה במחלקת בסיס משותפת המימושים. ממנה ירשו שלושת? <<class>> CartesianPoint <<interface>> IPoint <<abstract>> AbstPoint <<class>> PolarPoint <<class>> SmartPoint

9 9 מחלקות מופשטות Abstract Classes מחלקה מופשטת מוגדרת ע"י המלה השמורה abstract לא ניתן ליצור מופע של מחלקה מופשטת )בדומה למנשק( יכולה לממש מנשק מבלי לממש את כל השירותים המוגדרים בו זהו מנגנון המועיל להימנע משכפול קוד במחלקות יורשות

10 10 מחלקות מופשטות - דוגמא public abstract class A { public void f() { System.out.println( A.f!! ); abstract public void g(); A a = new A(); public class B extends A { public void g() { System.out.println( B.g!! ); A a = new B(); X

11 11 CartesianPoint PolarPoint private double x; private double y; public CartesianPoint(double x, double y) { this.x = x; this.y = y; public double getx() { return x; public double gety() { return y; public double rho() { return Math.sqrt(x*x + y*y); public double theta() { return Math.atan2(y,x); private double r; private double theta; public PolarPoint(double r, double theta) { this.r = r; this.theta = theta; public double getx() { return r * Math.cos(theta); public double gety() { return r * Math.sin(theta); public double rho() { return r; public double theta() { return theta; קשה לראות דמיון בין מימושי המתודות במקרה זה. כל 4 המתודות בסיסיות ויש להן קשר הדוק לייצוג שנבחר לשדות

12 13 CartesianPoint PolarPoint public double distance(ipoint other) { return Math.sqrt((x-other.getX()) * (x-other.getx()) + (y-other.gety())*(y-other.gety())); public double distance(ipoint other) { double deltax = getx()-other.getx(); double deltay = gety()-other.gety(); return Math.sqrt(deltaX * deltax + deltay * deltay); הקוד דומה אבל לא זהה, נראה מה ניתן לעשות... ו- deltay ננסה לשכתב את CartesianPoint ע"י הוספת משתני העזר deltax

13 14 CartesianPoint PolarPoint public double distance(ipoint other) { double deltax = x-other.getx(); double deltay = y-other.gety(); public double distance(ipoint other) { double deltax = getx()-other.getx(); double deltay = gety()-other.gety(); return Math.sqrt(deltaX * deltax + (deltay * deltay ); return Math.sqrt(deltaX * deltax + deltay * deltay); נשאר הבדל אחד: נחליף את x להיות getx() במאזן ביצועים לעומת כלליות נעדיף תמיד את הכלליות

14 15 CartesianPoint PolarPoint public double distance(ipoint other) { double deltax = getx()-other.getx(); double deltay = gety()-other.gety(); public double distance(ipoint other) { double deltax = getx()-other.getx(); double deltay = gety()-other.gety(); return Math.sqrt(deltaX * deltax + deltay * deltay ); return Math.sqrt(deltaX * deltax + deltay * deltay ); שתי המתודות זהות לחלוטין! עתה ניתן להעביר את המתודה למחלקה AbstPoint ולמחוק אותה מהמחלקות CartesianPoint ו- PolarPoint

15 16 CartesianPoint PolarPoint public String tostring(){ return "(x=" + x + ", y=" + y + ", r=" + rho() + ", theta=" + theta() + ")"; public String tostring() { return "(x=" + getx() + ", y=" + gety() + ", r=" + r + ", theta=" + theta + ")"; תהליך דומה ניתן גם לבצע עבור tostring

16 17 מימוש המחלקה האבסטרקטית public abstract class AbstractPoint implements IPoint{ public double distance(ipoint other) { double deltax = getx()-other.getx(); double deltay = gety()-other.gety(); return Math.sqrt(deltaX * deltax + deltay * deltay ); public String tostring() { return "(x=" + getx() + ", y=" + gety() + ", r=" + rho() + ", theta=" + theta() + ")";

17 18 public class PolarPoint extends AbstractPoint{ ירושה מהמחלקה האבסטרקטית private double r; private double theta; public PolarPoint(double r, double theta) { this.r = r; this.theta = public double getx() { return r * public void rotate(double angle) { theta += angle;

18 19 חריגים נממש שירות המחשב ממוצע הרמוני על אוסף של מספרים. public static double harmonicmean(collection<integer> numbers){ { if (numbers.isempty()){ return 0; double denominator = 0; for (int i : numbers){ denominator += 1.0/i; return numbers.size()/ denominator; שאלה: ממוצע הרמוני מוגדר רק על מספרים חיוביים. מה נעשה אם נקבל מספר אי-חיובי ברשימה?

19 20 אופציה ראשונה: נקבל החלטה בתוך השירות, חריגים למשל: נתעלם מהמספרים האי-חיוביים ונחשב ממוצע הרמוני על שאר המספרים. נחזיר 0 או מספר ברירת מחדל אחר חסרונות המשתמש לא ידע שמשהו לא תקין, אם היה יודע, אולי היה מעדיף דרך אחרת לטיפול. אופציה שניה: שימוש בחריגים.

20 21 חריגים public static double harmonicmean(collection<integer> numbers) throws Exception{ { if (numbers.isempty()){ return 0; double denominator = 0; for (int i : numbers){ if (i <= 0){ throw new Exception("wrong value in list: " + i); denominator += 1.0/i; return numbers.size()/denominator; מצהירים על שגיאה שנזרקת בשירות עלינו לייצר אובייקט חדש מטיפוס Exception ולהשתמש במילה השמורה throw בשביל לזרוק את השגיאה

21 22 חריגים נוסיף שירות נוסף השירות מקבל מפה: משם קובץ לאוסף המספרים שהוא מכיל, ומדפיס ממוצע הרמוני עבור כל קובץ. public static void printmeansbyfiles(map<string, Collection<Integer>> numbers) { for (Map.Entry<String, Collection<Integer>> mapentry: numbers.entryset()){ double hmeanforfile = harmonicmean(mapentry.getvalue()); System.out.println("for file: " + mapentry.getkey() + " hmean is: " + hmeanforfile); Exception בקוד הזה יש שגיאת קומפילציה בגלל שגיאה שלא הצהרנו עליה אך גם לא טיפלנו בה

22 23 חריגים אפשרות ראשונה: לא נטפל בחריג, ורק נצהיר עליו במקרה הזה, מי שיצטרך להתמודד עם הטיפול בחריג הוא השירות שיקרא ל.printMeansByFiles public static void printmeansbyfiles(map<string, Collection<Integer>> filesinfo) throws Exception{ for (Map.Entry<String, Collection<Integer>> mapentry: filesinfo.entryset()){ double hmeanforfile = harmonicmean(mapentry.getvalue()); System.out.println("for file: " + mapentry.getkey() + " hmean is: " + hmeanforfile);

23 24 אפשרות שניה: נטפל בחריג! חריגים public static void printmeansbyfiles(map<string, Collection<Integer>> filesinfo) { for (Map.Entry<String, Collection<Integer>> mapentry: filesinfo.entryset()){ try{ double hmeanforfile = harmonicmean(mapentry.getvalue()); System.out.println("for file: " + mapentry.getkey() + " hmean is: " + hmeanforfile); catch (Exception e){ System.out.println("cannot calculate hmean for file " + mapentry.getkey());

24 25 חריגים איך זה עובד? public static void main(string[] args){ Map<String, Collection<Integer>> files = new LinkedHashMap<>(); files.put("file1", Arrays.asList(1, 2, 3)); files.put("file2", Arrays.asList(1,2,-4)); files.put("file3", Arrays.asList(15,17,30)); printmeansbyfiles(files); תוכנית זו מייצרת את הפלט:

25 26 חריגים ובכל זאת יש בעיה אנחנו מטפלים בכל שגיאה אפשרית שיכולה להיזרק מתוך,harmonicMean ועל הדרך יכולים להתעלם משגיאות שמעידות על באג אפשרי. במימוש שלנו הנחנו הנחה סמויה לגבי המפה, למרות שאין לנו דרך לדעת כיצד היא נוצרה )נניח שאין חוזה לשירות(. מה יקרה במקרה הבא? public static void main(string[] args){ Map<String, Collection<Integer>> files = new LinkedHashMap<>(); files.put("file1", null); files.put("file2", Arrays.asList(1,2,-4)); files.put("file3", Arrays.asList(15,17,30)); printmeansbyfiles(files);

26 27 חריגים public static double harmonicmean(collection<integer> numbers) throws Exception{ if (numbers.isempty()) NullPointerException public static void printmeansbyfiles(map<string, Collection<Integer>> filesinfo) catch (Exception e){ System.out.println("cannot calculate hmean for file " + mapentry.getkey());

27 28 חריגים מה נרצה לעשות במידה והמפה שלי מכילה?null יכול להיות שנרצה להתייחס לזה כמו לרשימה ריקה )שזה למעשה הטיפול שקיים כרגע בקוד(. יכול להיות שנרצה להדפיס הודעה למשתמש: המפה מכילה,null אולי קרתה שגיאה בטעינת הקובץ? יכול להיות שנרצה לזרוק את השגיאה ולהטיל את הטיפול על מי שמשתמש ב printmeansbyfiles אם נרצה להתייחס למקרה של מפה המכילה null באופן שונה ממפה המכילה מספר לא חיובי, עלינו לדעת להבדיל בין החריגים. הצעה: נוסיף בלוק NullPointerException עבור except ומה אם יש עוד שגיאות שיכולות להיזרק?

28 29 יצירת טיפוס חריג חדש ירושה מ Exception class HMeanException extends Exception{ public HMeanException(String message) { super("harmonic Mean calculation error! " + message); { קריאה לבנאי של מחלקת האב קריאה זו תמיד תהיה הפקודה הראשונה של הבנאי

29 30 שימוש בטיפוס החריג החדש public static double harmonicmean(collection<integer> numbers) throws HMeanException { if (numbers.isempty()){ return 0; double denominator = 0; for (int i : numbers){ if (i <= 0){ throw new HMeanException("wrong value in list: " + i); denominator+ = 1.0/i; return numbers.size()/denominator; {

30 31 שימוש בטיפוס החריג החדש public static void printmeansbyfiles(map<string, Collection<Integer>> filesinfo) catch (HMeanException e){ System.out.println("cannot calculate hmean for file " + mapentry.getkey()); הבלוק הזה יטפל רק בשגיאה שזרקנו מתוך,harmonicMean חריגים אחרים יזרקו הלאה.

31 32 שימוש בשגיאות פורמט הודעת השגיאה public static void printmeansbyfiles(map<string, Collection<Integer>> filesinfo) catch (HMeanException e){ System.out.println("cannot calculate hmean for file " + mapentry.getkey()); e.printstacktrace(); { public static void main(string[] args){ Map<String, Collection<Integer>> files = new LinkedHashMap<>(); files.put("file2", Arrays.asList(1,2,-4)); files.put("file3", Arrays.asList(15,17,30)); printmeansbyfiles(files); עבור תוכנית זו נקבל את הפלט:

32 33 שימוש בשגיאות הדפסת פורמט שגיאה מצומצם יותר: public static void printmeansbyfiles(map<string, Collection<Integer>> filesinfo) catch (HMeanException e){ System.out.println("cannot calculate hmean for file " + mapentry.getkey()); System.out.println(e.getMessage()) { פלט התוכנית יהיה: class HMeanException extends Exception{ public HMeanException(String message) { super("harmonic Mean calculation error! " + message);